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

data/spec/lib/puppet_spec/ssl.rb

@@ -1,265 +0,0 @@
-require 'openssl'
-
-module PuppetSpec
-  module SSL
-
-    PRIVATE_KEY_LENGTH = 2048
-    FIVE_YEARS = 5 * 365 * 24 * 60 * 60
-    CA_EXTENSIONS = [
-      ["basicConstraints", "CA:TRUE", true],
-      ["keyUsage", "keyCertSign, cRLSign", true],
-      ["subjectKeyIdentifier", "hash", false],
-      ["authorityKeyIdentifier", "keyid:always", false]
-    ]
-    NODE_EXTENSIONS = [
-      ["keyUsage", "digitalSignature", true],
-      ["subjectKeyIdentifier", "hash", false]
-    ]
-    DEFAULT_SIGNING_DIGEST = OpenSSL::Digest::SHA256.new
-    DEFAULT_REVOCATION_REASON = OpenSSL::OCSP::REVOKED_STATUS_KEYCOMPROMISE
-    ROOT_CA_NAME = "/CN=root-ca-\u{2070E}"
-    REVOKED_INT_CA_NAME = "/CN=revoked-int-ca-\u16A0"
-    INT_CA_NAME = "/CN=unrevoked-int-ca\u06FF\u16A0\u{2070E}"
-    LEAF_CA_NAME = "/CN=leaf-ca-\u06FF"
-    EXPLANATORY_TEXT = <<-EOT
-# Root Issuer: #{ROOT_CA_NAME}
-# Intermediate Issuer: #{INT_CA_NAME}
-# Leaf Issuer: #{LEAF_CA_NAME}
-EOT
-
-
-    def self.create_private_key(length = PRIVATE_KEY_LENGTH)
-      OpenSSL::PKey::RSA.new(length)
-    end
-
-    def self.self_signed_ca(key, name)
-      cert = OpenSSL::X509::Certificate.new
-
-      cert.public_key = key.public_key
-      cert.subject = OpenSSL::X509::Name.parse(name)
-      cert.issuer = cert.subject
-      cert.version = 2
-      cert.serial = rand(2**128)
-
-      not_before = just_now
-      cert.not_before = not_before
-      cert.not_after = not_before + FIVE_YEARS
-
-      ext_factory = extension_factory_for(cert, cert)
-      CA_EXTENSIONS.each do |ext|
-        extension = ext_factory.create_extension(*ext)
-        cert.add_extension(extension)
-      end
-
-      cert.sign(key, DEFAULT_SIGNING_DIGEST)
-
-      cert
-    end
-
-    def self.create_csr(key, name)
-      csr = OpenSSL::X509::Request.new
-
-      csr.public_key = key.public_key
-      csr.subject = OpenSSL::X509::Name.parse(name)
-      csr.version = 2
-      csr.sign(key, DEFAULT_SIGNING_DIGEST)
-
-      csr
-    end
-
-    def self.sign(ca_key, ca_cert, csr, extensions = NODE_EXTENSIONS)
-      cert = OpenSSL::X509::Certificate.new
-
-      cert.public_key = csr.public_key
-      cert.subject = csr.subject
-      cert.issuer = ca_cert.subject
-      cert.version = 2
-      cert.serial = rand(2**128)
-
-      not_before = just_now
-      cert.not_before = not_before
-      cert.not_after = not_before + FIVE_YEARS
-
-      ext_factory = extension_factory_for(ca_cert, cert)
-      extensions.each do |ext|
-        extension = ext_factory.create_extension(*ext)
-        cert.add_extension(extension)
-      end
-
-      cert.sign(ca_key, DEFAULT_SIGNING_DIGEST)
-
-      cert
-    end
-
-    def self.create_crl_for(ca_cert, ca_key)
-      crl = OpenSSL::X509::CRL.new
-      crl.version = 1
-      crl.issuer = ca_cert.subject
-
-      ef = extension_factory_for(ca_cert)
-      crl.add_extension(
-        ef.create_extension(["authorityKeyIdentifier", "keyid:always", false]))
-      crl.add_extension(
-        OpenSSL::X509::Extension.new("crlNumber", OpenSSL::ASN1::Integer(0)))
-
-      not_before = just_now
-      crl.last_update = not_before
-      crl.next_update = not_before + FIVE_YEARS
-      crl.sign(ca_key, DEFAULT_SIGNING_DIGEST)
-
-      crl
-    end
-
-    def self.revoke(serial, crl, ca_key)
-      revoked = OpenSSL::X509::Revoked.new
-      revoked.serial = serial
-      revoked.time = Time.now
-      revoked.add_extension(
-        OpenSSL::X509::Extension.new("CRLReason",
-                                     OpenSSL::ASN1::Enumerated(DEFAULT_REVOCATION_REASON)))
-
-      crl.add_revoked(revoked)
-      extensions = crl.extensions.group_by{|e| e.oid == 'crlNumber' }
-      crl_number = extensions[true].first
-      unchanged_exts = extensions[false]
-
-      next_crl_number = crl_number.value.to_i + 1
-      new_crl_number_ext = OpenSSL::X509::Extension.new("crlNumber",
-                                                        OpenSSL::ASN1::Integer(next_crl_number))
-
-      crl.extensions = unchanged_exts + [new_crl_number_ext]
-      crl.sign(ca_key, DEFAULT_SIGNING_DIGEST)
-
-      crl
-    end
-
-    # Creates a self-signed root ca, then signs two node certs, revoking one of them.
-    # Creates an intermediate CA and one node cert off of it.
-    # Creates a second intermediate CA and one node cert off if it.
-    # Creates a leaf CA off of the intermediate CA, then signs two node certs revoking one of them.
-    # Revokes an intermediate CA.
-    # Returns the ca bundle, crl chain, and all the node certs
-    #
-    #            -----
-    #           /     \
-    #          /       \
-    #          | root  +-------------------o------------------o
-    #          \  CA   /                   |                  |
-    #           \     /                    |                  |
-    #            --+--                     |                  |
-    #              |                       |                  |
-    #              |                       |                  |
-    #              |                       |                  |
-    #              |                     --+--              --+--
-    # +---------+  |   +---------+      /     \            /     \
-    # | revoked |  |   |         |     /revoked\          /       \
-    # |   node  +--o---+   node  |     |  int  |          | int   |
-    # |         |      |         |     \  CA   /          \  CA   /
-    # +---------+      +---------+      \     /            \     /
-    #                                    --+--              --+--
-    #                                      |                  |
-    #                                      |                  |
-    #                                      |                  |
-    #                                    --+--                |
-    #                                   /     \           +---+-----+
-    #                                  /       \          |         |
-    #                                  | leaf  |          |  node   |
-    #                                  \  CA   /          |         |
-    #                                   \     /           +---------+
-    #                                    --+--
-    #                                      |
-    #                                      |
-    #                         +---------+  |  +----------+
-    #                         | revoked |  |  |          |
-    #                         |   node  +--o--+  node    |
-    #                         |         |     |          |
-    #                         +---------+     +----------+
-    def self.create_chained_pki
-      root_key = create_private_key
-      root_cert = self_signed_ca(root_key, ROOT_CA_NAME)
-      root_crl = create_crl_for(root_cert, root_key)
-
-      unrevoked_root_node_key = create_private_key
-      unrevoked_root_node_csr = create_csr(unrevoked_root_node_key, "/CN=unrevoked-root-node")
-      unrevoked_root_node_cert = sign(root_key, root_cert, unrevoked_root_node_csr)
-
-      revoked_root_node_key = create_private_key
-      revoked_root_node_csr = create_csr(revoked_root_node_key, "/CN=revoked-root-node")
-      revoked_root_node_cert = sign(root_key, root_cert, revoked_root_node_csr)
-
-      revoke(revoked_root_node_cert.serial, root_crl, root_key)
-
-      revoked_int_key = create_private_key
-      revoked_int_csr = create_csr(revoked_int_key, REVOKED_INT_CA_NAME)
-      revoked_int_cert = sign(root_key, root_cert, revoked_int_csr, CA_EXTENSIONS)
-      revoked_int_crl = create_crl_for(revoked_int_cert, revoked_int_key)
-
-      int_key = create_private_key
-      int_csr = create_csr(int_key, INT_CA_NAME)
-      int_cert = sign(root_key, root_cert, int_csr, CA_EXTENSIONS)
-
-      int_node_key = create_private_key
-      int_node_csr = create_csr(int_node_key, "/CN=unrevoked-int-node")
-      int_node_cert = sign(int_key, int_cert, int_node_csr)
-
-      unrevoked_int_node_key = create_private_key
-      unrevoked_int_node_csr = create_csr(unrevoked_int_node_key, "/CN=unrevoked-int-node")
-      unrevoked_int_node_cert = sign(revoked_int_key, revoked_int_cert, unrevoked_int_node_csr)
-
-      leaf_key = create_private_key
-      leaf_csr = create_csr(leaf_key, LEAF_CA_NAME)
-      leaf_cert = sign(revoked_int_key, revoked_int_cert, leaf_csr, CA_EXTENSIONS)
-      leaf_crl = create_crl_for(leaf_cert, leaf_key)
-
-      revoke(revoked_int_cert.serial, root_crl, root_key)
-
-      unrevoked_leaf_node_key = create_private_key
-      unrevoked_leaf_node_csr = create_csr(unrevoked_leaf_node_key, "/CN=unrevoked-leaf-node")
-      unrevoked_leaf_node_cert = sign(leaf_key, leaf_cert, unrevoked_leaf_node_csr)
-
-      revoked_leaf_node_key = create_private_key
-      revoked_leaf_node_csr = create_csr(revoked_leaf_node_key, "/CN=revoked-leaf-node")
-      revoked_leaf_node_cert = sign(leaf_key, leaf_cert, revoked_leaf_node_csr)
-
-      revoke(revoked_leaf_node_cert.serial, leaf_crl, leaf_key)
-
-
-      ca_bundle = bundle(root_cert, revoked_int_cert, leaf_cert)
-      crl_chain = bundle(root_crl, revoked_int_crl, leaf_crl)
-
-      {
-        :root_cert => root_cert,
-        :int_cert => int_cert,
-        :int_node_cert => int_node_cert,
-        :leaf_cert => leaf_cert,
-        :leaf_key => leaf_key,
-        :revoked_root_node_cert => revoked_root_node_cert,
-        :revoked_int_cert => revoked_int_cert,
-        :revoked_leaf_node_cert => revoked_leaf_node_cert,
-        :unrevoked_root_node_cert => unrevoked_root_node_cert,
-        :unrevoked_int_node_cert  => unrevoked_int_node_cert,
-        :unrevoked_leaf_node_cert => unrevoked_leaf_node_cert,
-        :ca_bundle => ca_bundle,
-        :crl_chain => crl_chain,
-      }
-    end
-
-   private
-
-    def self.just_now
-      Time.now - 1
-    end
-
-    def self.extension_factory_for(ca, cert = nil)
-      ef = OpenSSL::X509::ExtensionFactory.new
-      ef.issuer_certificate  = ca
-      ef.subject_certificate = cert if cert
-
-      ef
-    end
-
-    def self.bundle(*items)
-      items.map {|i| EXPLANATORY_TEXT + i.to_pem }.join("\n")
-    end
-  end
-end

data/spec/lib/puppet_spec/unindent.rb

@@ -1,5 +0,0 @@
-class String
-  def unindent(left_padding = '')
-    gsub(/^#{scan(/^\s*/).min_by{ |l| l.length }}/, left_padding)
-  end
-end

data/spec/lib/puppet_spec/verbose.rb

@@ -1,9 +0,0 @@
-# Support code for running stuff with warnings disabled.
-module Kernel
-  def with_verbose_disabled
-    verbose, $VERBOSE = $VERBOSE, nil
-    result = yield
-    $VERBOSE = verbose
-    return result
-  end
-end

data/spec/shared_behaviours/all_parsedfile_providers.rb

@@ -1,21 +0,0 @@
-shared_examples_for "all parsedfile providers" do |provider, *files|
-  if files.empty? then
-    files = my_fixtures
-  end
-
-  files.flatten.each do |file|
-    it "should rewrite #{file} reasonably unchanged" do
-      allow(provider).to receive(:default_target).and_return(file)
-      provider.prefetch
-
-      text = provider.to_file(provider.target_records(file))
-      text.gsub!(/^# HEADER.+\n/, '')
-
-      oldlines = File.readlines(file)
-      newlines = text.chomp.split "\n"
-      oldlines.zip(newlines).each do |old, new|
-        expect(new.gsub(/\s+/, '')).to eq(old.chomp.gsub(/\s+/, ''))
-      end
-    end
-  end
-end

data/spec/shared_behaviours/an_indirector_face.rb

@@ -1,6 +0,0 @@
-shared_examples_for "an indirector face" do
-  [:find, :search, :save, :destroy, :info].each do |action|
-    it { is_expected.to be_action action }
-    it { is_expected.to respond_to action }
-  end
-end

data/spec/shared_behaviours/documentation_on_faces.rb

@@ -1,261 +0,0 @@
-# encoding: UTF-8
-shared_examples_for "documentation on faces" do
-  defined?(Attrs) or
-    Attrs = [:summary, :description, :examples, :short_description, :notes, :author]
-
-  defined?(SingleLineAttrs) or
-    SingleLineAttrs = [:summary, :author]
-
-  # Simple, procedural tests that apply to a bunch of methods.
-  Attrs.each do |attr|
-    it "should accept a #{attr}" do
-      expect { subject.send("#{attr}=", "hello") }.not_to raise_error
-      expect(subject.send(attr)).to eq("hello")
-    end
-
-    it "should accept a long (single line) value for #{attr}" do
-      text = "I never know when to stop with the word banana" + ("na" * 1000)
-      expect { subject.send("#{attr}=", text) }.to_not raise_error
-      expect(subject.send(attr)).to eq(text)
-    end
-  end
-
-  Attrs.each do |getter|
-    setter = "#{getter}=".to_sym
-    context "#{getter}" do
-      it "should strip leading whitespace on a single line" do
-        subject.send(setter, "  death to whitespace")
-        expect(subject.send(getter)).to eq("death to whitespace")
-      end
-
-      it "should strip trailing whitespace on a single line" do
-        subject.send(setter, "death to whitespace  ")
-        expect(subject.send(getter)).to eq("death to whitespace")
-      end
-
-      it "should strip whitespace at both ends at once" do
-        subject.send(setter, "  death to whitespace  ")
-        expect(subject.send(getter)).to eq("death to whitespace")
-      end
-
-      multiline_text = "with\nnewlines"
-      if SingleLineAttrs.include? getter then
-        it "should not accept multiline values" do
-          expect { subject.send(setter, multiline_text) }.
-            to raise_error ArgumentError, /#{getter} should be a single line/
-          expect(subject.send(getter)).to be_nil
-        end
-      else
-        it "should accept multiline values" do
-          expect { subject.send(setter, multiline_text) }.not_to raise_error
-          expect(subject.send(getter)).to eq(multiline_text)
-        end
-
-        [1, 2, 4, 7, 25].each do |length|
-          context "#{length} chars indent" do
-            indent = ' ' * length
-
-            it "should strip leading whitespace on multiple lines" do
-              text = "this\nis\the\final\outcome"
-              subject.send(setter, text.gsub(/^/, indent))
-              expect(subject.send(getter)).to eq(text)
-            end
-
-            it "should not remove formatting whitespace, only global indent" do
-              text = "this\n  is\n    the\n  ultimate\ntest"
-              subject.send(setter, text.gsub(/^/, indent))
-              expect(subject.send(getter)).to eq(text)
-            end
-          end
-        end
-
-        it "should strip whitespace with a blank line" do
-          subject.send(setter, "  this\n\n  should outdent")
-          expect(subject.send(getter)).to eq("this\n\nshould outdent")
-        end
-      end
-    end
-  end
-
-  describe "#short_description" do
-    it "should return the set value if set after description" do
-      subject.description = "hello\ngoodbye"
-      subject.short_description = "whatever"
-      expect(subject.short_description).to eq("whatever")
-    end
-
-    it "should return the set value if set before description" do
-      subject.short_description = "whatever"
-      subject.description = "hello\ngoodbye"
-      expect(subject.short_description).to eq("whatever")
-    end
-
-    it "should return nothing if not set and no description" do
-      expect(subject.short_description).to be_nil
-    end
-
-    it "should return the first paragraph of description if not set (where it is one line long)" do
-      subject.description = "hello"
-      expect(subject.short_description).to eq(subject.description)
-    end
-
-    it "should return the first paragraph of description if not set (where there is no paragraph break)" do
-      subject.description = "hello\ngoodbye"
-      expect(subject.short_description).to eq(subject.description)
-    end
-
-    it "should return the first paragraph of description if not set (where there is a paragraph break)" do
-      subject.description = "hello\ngoodbye\n\nmore\ntext\nhere\n\nfinal\nparagraph"
-      expect(subject.short_description).to eq("hello\ngoodbye")
-    end
-
-    it "should trim a very, very long first paragraph and add ellipsis" do
-      line = "this is a very, very, very long long line full of text\n"
-      subject.description = line * 20 + "\n\nwhatever, dude."
-
-      expect(subject.short_description).to eq((line * 5).chomp + ' [...]')
-    end
-
-    it "should trim a very very long only paragraph even if it is followed by a new paragraph" do
-      line = "this is a very, very, very long long line full of text\n"
-      subject.description = line * 20
-
-      expect(subject.short_description).to eq((line * 5).chomp + ' [...]')
-    end
-  end
-
-  describe "multiple authors" do
-    authors = %w{John Paul George Ringo}
-
-    context "in the DSL" do
-      it "should support multiple authors" do
-
-        authors.each {|name| subject.author name }
-        expect(subject.authors).to match_array(authors)
-
-        expect(subject.author).to eq(authors.join("\n"))
-      end
-
-      it "should reject author as an array" do
-        expect { subject.author ["Foo", "Bar"] }.
-          to raise_error ArgumentError, /author must be a string/
-      end
-    end
-
-    context "#author=" do
-      it "should accept a single name" do
-        subject.author = "Fred"
-        expect(subject.author).to eq("Fred")
-      end
-
-      it "should accept an array of names" do
-        subject.author = authors
-        expect(subject.authors).to match_array(authors)
-        expect(subject.author).to eq(authors.join("\n"))
-      end
-
-      it "should not append when set multiple times" do
-        subject.author = "Fred"
-        subject.author = "John"
-        expect(subject.author).to eq("John")
-      end
-
-      it "should reject arrays with embedded newlines" do
-        expect { subject.author = ["Fred\nJohn"] }.
-          to raise_error ArgumentError, /author should be a single line/
-      end
-    end
-  end
-
-  describe "#license" do
-    it "should default to reserving rights" do
-      expect(subject.license).to match(/All Rights Reserved/)
-    end
-
-    it "should accept an arbitrary license string on the object" do
-      subject.license = "foo"
-      expect(subject.license).to eq("foo")
-    end
-  end
-
-  describe "#copyright" do
-    it "should fail with just a name" do
-      expect { subject.copyright("invalid") }.
-        to raise_error ArgumentError, /copyright takes the owners names, then the years covered/
-    end
-
-    [1997, "1997"].each do |year|
-      it "should accept an entity name and a #{year.class.name} year" do
-        subject.copyright("me", year)
-        expect(subject.copyright).to match(/\bme\b/)
-        expect(subject.copyright).to match(/#{year}/)
-      end
-
-      it "should accept multiple entity names and a #{year.class.name} year" do
-        subject.copyright ["me", "you"], year
-        expect(subject.copyright).to match(/\bme\b/)
-        expect(subject.copyright).to match(/\byou\b/)
-        expect(subject.copyright).to match(/#{year}/)
-      end
-    end
-
-    ["1997-2003", "1997 - 2003", 1997..2003].each do |range|
-      it "should accept a #{range.class.name} range of years" do
-        subject.copyright("me", range)
-        expect(subject.copyright).to match(/\bme\b/)
-        expect(subject.copyright).to match(/1997-2003/)
-      end
-
-      it "should accept a #{range.class.name} range of years" do
-        subject.copyright ["me", "you"], range
-        expect(subject.copyright).to match(/\bme\b/)
-        expect(subject.copyright).to match(/\byou\b/)
-        expect(subject.copyright).to match(/1997-2003/)
-      end
-    end
-
-    [[1997, 2003], ["1997", 2003], ["1997", "2003"]].each do |input|
-      it "should accept the set of years #{input.inspect} in an array" do
-        subject.copyright "me", input
-        expect(subject.copyright).to match(/\bme\b/)
-        expect(subject.copyright).to match(/1997, 2003/)
-      end
-
-      it "should accept the set of years #{input.inspect} in an array" do
-        subject.copyright ["me", "you"], input
-        expect(subject.copyright).to match(/\bme\b/)
-        expect(subject.copyright).to match(/\byou\b/)
-        expect(subject.copyright).to match(/1997, 2003/)
-      end
-    end
-
-    it "should warn if someone does math accidentally on the range of years" do
-      expect { subject.copyright "me", 1997-2003 }.
-        to raise_error ArgumentError, /copyright with a year before 1970 is very strange; did you accidentally add or subtract two years\?/
-    end
-
-    it "should accept complex copyright years" do
-      years = [1997, 1999, 2000..2002, 2005].reverse
-      subject.copyright "me", years
-      expect(subject.copyright).to match(/\bme\b/)
-      expect(subject.copyright).to match(/1997, 1999, 2000-2002, 2005/)
-    end
-  end
-
-  # Things that are automatically generated.
-  [:name, :options, :synopsis].each do |attr|
-    describe "##{attr}" do
-      it "should not allow you to set #{attr}" do
-        expect(subject).not_to respond_to :"#{attr}="
-      end
-
-      it "should have a #{attr}" do
-        expect(subject.send(attr)).not_to be_nil
-      end
-
-      it "'s #{attr} should not be empty..." do
-        expect(subject.send(attr)).not_to eq('')
-      end
-    end
-  end
-end

data/spec/shared_behaviours/file_server_terminus.rb

@@ -1,38 +0,0 @@
-shared_examples_for "Puppet::Indirector::FileServerTerminus" do
-  # This only works if the shared behaviour is included before
-  # the 'before' block in the including context.
-  before do
-    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:fileserverconfig]).and_return(true)
-
-    @path = Tempfile.new("file_server_testing")
-    path = @path.path
-    @path.close!
-    @path = path
-
-    Dir.mkdir(@path)
-    File.open(File.join(@path, "myfile"), "w") { |f| f.print "my content" }
-
-    # Use a real mount, so the integration is a bit deeper.
-    @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
-    @mount1.path = @path
-
-    @parser = double('parser', :changed? => false)
-    allow(@parser).to receive(:parse).and_return("one" => @mount1)
-
-    allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
-
-    # Stub out the modules terminus
-    @modules = double('modules terminus')
-
-    @request = Puppet::Indirector::Request.new(:indirection, :method, "puppet://myhost/one/myfile", nil)
-  end
-
-  it "should use the file server configuration to find files" do
-    allow(@modules).to receive(:find).and_return(nil)
-    allow(@terminus.indirection).to receive(:terminus).with(:modules).and_return(@modules)
-
-    expect(@terminus.find(@request)).to be_instance_of(@test_class)
-  end
-end

data/spec/shared_behaviours/file_serving.rb

@@ -1,73 +0,0 @@
-shared_examples_for "Puppet::FileServing::Files" do |indirection|
-  %w[find search].each do |method|
-    let(:request) { Puppet::Indirector::Request.new(indirection, method, 'foo', nil) }
-
-    describe "##{method}" do
-      it "should proxy to file terminus if the path is absolute" do
-        request.key = make_absolute('/tmp/foo')
-
-        expect_any_instance_of(described_class.indirection.terminus(:file).class).to receive(method).with(request)
-
-        subject.send(method, request)
-      end
-
-      it "should proxy to file terminus if the protocol is file" do
-        request.protocol = 'file'
-
-        expect_any_instance_of(described_class.indirection.terminus(:file).class).to receive(method).with(request)
-
-        subject.send(method, request)
-      end
-
-      describe "when the protocol is puppet" do
-        before :each do
-          request.protocol = 'puppet'
-        end
-
-        describe "and a server is specified" do
-          before :each do
-            request.server = 'puppet_server'
-          end
-
-          it "should proxy to rest terminus if default_file_terminus is rest" do
-            Puppet[:default_file_terminus] = "rest"
-
-            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
-
-            subject.send(method, request)
-          end
-
-          it "should proxy to rest terminus if default_file_terminus is not rest" do
-            Puppet[:default_file_terminus] = 'file_server'
-
-            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
-
-            subject.send(method, request)
-          end
-        end
-
-        describe "and no server is specified" do
-          before :each do
-            request.server = nil
-          end
-
-          it "should proxy to file_server if default_file_terminus is 'file_server'" do
-            Puppet[:default_file_terminus] = 'file_server'
-
-            expect_any_instance_of(described_class.indirection.terminus(:file_server).class).to receive(method).with(request)
-
-            subject.send(method, request)
-          end
-
-          it "should proxy to rest if default_file_terminus is 'rest'" do
-            Puppet[:default_file_terminus] = "rest"
-
-            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
-
-            subject.send(method, request)
-          end
-        end
-      end
-    end
-  end
-end